package com.yjhh.scala


/**
  * 1.在Scala的集合体系中Iterable是共同的Trait，Iterable要求继承者实现一些共同的方法，例如对元素的遍历
  * 2.Array是一个非常基础的数据结构，不从属与Scala集合的体系
  * 3.Scala的集合体系中集合分为可变集合与不可变结合之分；
  * 不可变的集合在scala.collection.immutable包中
  * 可变的集合在scala.collection.mutable包中
  * 4.List是元素的列表集合，是不可变的
  * 第一点：List中head是指第一个元素，tail是指剩下的元素构成的List集合
  * 第二点：使用::这个操作符号来把List的元素进行组拼来构建新的List
  * 5.LinkedList是元素可变的列表
  * 6.Set是元素不可重复的集合，但是是无序的,HashSet元素不可重复、元素可变、无序的集合
  * 7.LinkedHashSet会维护元素插入的顺序
  * 8.SortedSet是可排序的Set
  */
object FunctionalIterable {

  def main(args: Array[String]): Unit = {
    val range = 1 to 10

    val list = List(1, 2, 3, 4, 5)
    //    println(list.head)
    println(list.tail)

    val newList = list :: List(4, 5, 6, 7)
    val newList2 = (10, 11) :: List(4, 5, 6, 7)
    val newList3 = 12 :: List(4, 5, 6, 7)
    println(newList)
    println(newList2)
    println(newList3)

    var linkedList = scala.collection.mutable.LinkedList(1, 2, 3, 4, 5)
    println(linkedList.elem)
    println(linkedList.tail)

    while (linkedList != Nil) {
      println(linkedList.elem)
      linkedList = linkedList.tail //除了最开始元素之后的元素
    }

    println(linkedList)

    val copied = linkedList.+:("111", "2222")
    println(copied)


    val set = Set(1, 2, 3, 4, 5)
    println(set)

    val setMore = set + 1
    println(setMore)

    val hashSet = scala.collection.mutable.HashSet(1, 2, 3, 4, 5)
    println(hashSet)
    val hashSet1 = hashSet + 1
    println(hashSet1)

    val linkedHashSet = scala.collection.mutable.LinkedHashSet(1, 2, 3, 4, 5)
    println(linkedHashSet)
    linkedHashSet += 4
    linkedHashSet += 50
    linkedHashSet += 5
    println(linkedHashSet)

    val sortedSet = scala.collection.mutable.SortedSet(2, 4, 1, 0, 3, 5)
    println(sortedSet)
    sortedSet += -10
    println(sortedSet)


    val listPro = List("I am into spark so much!").map(str => str.split(" "))
    for (str <- listPro) println(str.mkString("#"))

    val listPro2 = List("I am into spark so much!", "Scala is powerful!").flatMap(str => str.split(" "))
    for (str <- listPro2) println(str)

    println(listPro2)

    println(listPro2.map(str => (str, 1)).map(str => str._2).reduce(_ + _))
    println(listPro2.map((_, 1)).map(_._2).reduce(_ + _))
    println(listPro2.map((_, 1)).map(_._2).reduce((x, y) => x + y)) //(x, y) => x + y)   表示前边元素的结果加上下一个元素

    List(1, 2, 3, 4, 5, 6).foreach { num => println(num) }
    List(1, 2, 3, 4, 5, 6).foreach { println(_) }     //只有一个参数时可以使用占位符
    List(1, 2, 3, 4, 5, 6).foreach { println _ }     //只有一个参数时可以使用占位符,和去掉括号
    List(1, 2, 3, 4, 5, 6).foreach { println _ }     //只有一个参数时可以使用占位符,和去掉括号
    List(1, 2, 3, 4, 5, 6).foreach { println }     //括号和占位符都可以去掉
    List(1, 2, 3, 4, 5, 6).foreach(println)     //当只有行语句时，可以使用()来包含函数体内容

  }


}
